/**
 * 默认后端服务地址（当未配置 VITE_API_BASE_URL 时生效）
 */
const DEFAULT_BASE_URL = 'http://127.0.0.1:5000'

/**
 * 统一的 API 基础地址，会优先读取运行时环境变量
 */
const API_BASE_URL = import.meta.env?.VITE_API_BASE_URL || DEFAULT_BASE_URL
const AUTH_TOKEN_KEY = 'ie-platform-token'
const AUTH_USER_KEY = 'ie-platform-user'

/**
 * 构造带查询参数的完整请求 URL
 * @param {string} path - API 路径（形如 /api/posts）
 * @param {Record<string, any>} [params] - 可选的查询参数
 */
function buildUrl(path, params) {
  const url = new URL(path, API_BASE_URL)
  if (params && typeof params === 'object') {
    Object.entries(params)
      .filter(([, value]) => value !== undefined && value !== null && value !== '')
      .forEach(([key, value]) => {
        if (Array.isArray(value)) {
          value.forEach((item) => url.searchParams.append(key, item))
        } else {
          url.searchParams.append(key, value)
        }
      })
  }
  return url.toString()
}

/**
 * 从本地存储读取浏览器持久化的 token
 */
function getStoredToken() {
  if (typeof window === 'undefined') return ''
  try {
    return localStorage.getItem(AUTH_TOKEN_KEY) || ''
  } catch (error) {
    console.warn('读取 token 失败', error)
    return ''
  }
}

/**
 * 持久化登录态（token 与用户信息），便于前后端交互时复用
 */
export function saveAuthSession({ token, user }) {
  if (typeof window === 'undefined') return
  try {
    if (token) {
      localStorage.setItem(AUTH_TOKEN_KEY, token)
    } else {
      localStorage.removeItem(AUTH_TOKEN_KEY)
    }
    if (user) {
      localStorage.setItem(AUTH_USER_KEY, JSON.stringify(user))
    } else {
      localStorage.removeItem(AUTH_USER_KEY)
    }
  } catch (error) {
    console.warn('保存登录状态失败', error)
  }
}

/**
 * 获取当前缓存的 token；供需要鉴权的请求动态注入
 */
export function getAuthToken() {
  return getStoredToken()
}

/**
 * 从本地存储恢复用户信息
 */
export function loadStoredUser() {
  if (typeof window === 'undefined') return null
  try {
    const raw = localStorage.getItem(AUTH_USER_KEY)
    return raw ? JSON.parse(raw) : null
  } catch (error) {
    console.warn('读取用户信息失败', error)
    return null
  }
}

/**
 * 清除登录态，登出时调用
 */
export function clearAuthSession() {
  if (typeof window === 'undefined') return
  try {
    localStorage.removeItem(AUTH_TOKEN_KEY)
    localStorage.removeItem(AUTH_USER_KEY)
  } catch (error) {
    console.warn('清除登录状态失败', error)
  }
}

/**
 * 基础请求封装，统一处理：
 *  - URL 拼接与查询参数
 *  - JSON 序列化 / FormData 透传
 *  - 鉴权 token 注入
 *  - 错误响应解析并抛出
 */
async function request(
  path,
  { method = 'GET', params, headers, body, auth = false, ...rest } = {},
) {
  const url = buildUrl(path, params)
  const isFormData = body instanceof FormData
  const token = auth ? getStoredToken() : ''
  const requestHeaders = {
    ...(isFormData ? {} : { 'Content-Type': 'application/json' }),
    ...headers,
  }
  if (auth && token) {
    requestHeaders.Authorization = `Bearer ${token}`
  }

  const fetchOptions = {
    method,
    headers: requestHeaders,
    ...rest,
  }

  if (body !== undefined) {
    fetchOptions.body =
      isFormData || typeof body === 'string' ? body : JSON.stringify(body)
  }

  const response = await fetch(url, fetchOptions)

  if (!response.ok) {
    const errorBody = await response.json().catch(() => null)
    const error = new Error(errorBody?.error || response.statusText || '请求失败')
    error.status = response.status
    error.body = errorBody
    throw error
  }

  if (response.status === 204) {
    return null
  }

  return response.json()
}

/**
 * -------- 内容展示相关接口 --------
 */
export function getSections() {
  return request('/api/sections')
}

export function getFounder() {
  return request('/api/content/founder')
}

export function getCarouselCards() {
  return request('/api/content/carousel')
}

export function getApplications(params) {
  return request('/api/applications', { params })
}

export function getPosts(params) {
  // 支持 keyword 和 author_id 查询参数
  // params: { keyword?: string, author_id?: number }
  return request('/api/posts', { params })
}

export function getPostDetail(id) {
  return request(`/api/posts/${id}`)
}

export function createPost(payload) {
  // 创建新帖子，如果用户已登录会自动使用当前用户的 author_id
  // payload: { title: string, content: string, tags?: string[] }
  return request('/api/posts', {
    method: 'POST',
    body: payload,
  })
}

export function createPostReply(id, payload) {
  // 未开启登录限制的示例接口，可直接发帖回复
  return request(`/api/posts/${id}/replies`, {
    method: 'POST',
    body: payload,
  })
}

export function getComments(params) {
  // 支持 target_type、target_id 和 author_id 查询参数
  // params: { target_type?: string, target_id?: string, author_id?: number }
  return request('/api/comments', { params })
}

export function createComment(payload) {
  return request('/api/comments', {
    method: 'POST',
    body: payload,
    auth: true,
  })
}

export function analyzeComment(payload) {
  // 发帖/评论前的内容审核，可选流程
  return request('/api/comments/analyze', {
    method: 'POST',
    body: payload,
  })
}

/**
 * -------- 用户账号相关接口 --------
 */
export function login(payload) {
  return request('/api/auth/login', {
    method: 'POST',
    body: payload,
  })
}

export function sendVerifyCode(payload) {
  return request('/api/auth/send-verify-code', {
    method: 'POST',
    body: payload,
  })
}

export function register(payload) {
  return request('/api/auth/register', {
    method: 'POST',
    body: payload,
  })
}

export function getCurrentUser() {
  return request('/api/users/me', {
    // 需后端鉴权的接口，需要附带 token
    auth: true,
  })
}

export function getMyPosts(params) {
  // 获取当前登录用户发布的所有帖子
  // 需要认证: 是（需携带 Authorization 头）
  // params: { keyword?: string } - 可选的关键字搜索
  return request('/api/users/me/posts', {
    params,
    auth: true,
  })
}

export function getMyComments(params) {
  // 获取当前登录用户发表的所有评论
  // 需要认证: 是（需携带 Authorization 头）
  return request('/api/users/me/comments', {
    params,
    auth: true,
  })
}

/**
 * -------- 平台元信息接口 --------
 */
export function getMetaTeam() {
  return request('/api/meta/team')
}

export function getMetaVersion() {
  return request('/api/meta/version')
}